##### 6.58.14.3 MIPS-3D Built-in Functions

The MIPS-3D Application-Specific Extension (ASE) includes additional paired-single instructions that are designed to improve the performance of 3D graphics operations. Support for these instructions is controlled by the `-mips3d` command-line option.

The functions listed below map directly to a particular MIPS-3D instruction. Please refer to the architecture specification for more details on what each instruction does.

`v2sf __builtin_mips_addr_ps (v2sf, v2sf)`
  Reduction add (`addr.ps`).
`v2sf __builtin_mips_mulr_ps (v2sf, v2sf)`
  Reduction multiply (`mulr.ps`).
`v2sf __builtin_mips_cvt_pw_ps (v2sf)`
  Convert paired single to paired word (`cvt.pw.ps`).
`v2sf __builtin_mips_cvt_ps_pw (v2sf)`
  Convert paired word to paired single (`cvt.ps.pw`).
`float __builtin_mips_recip1_s (float)`
`double __builtin_mips_recip1_d (double)`
`v2sf __builtin_mips_recip1_ps (v2sf)`
  Reduced-precision reciprocal (sequence step 1) (`recip1.`fmt).
`float __builtin_mips_recip2_s (float, float)`
`double __builtin_mips_recip2_d (double, double)`
`v2sf __builtin_mips_recip2_ps (v2sf, v2sf)`
  Reduced-precision reciprocal (sequence step 2) (`recip2.`fmt).
`float __builtin_mips_rsqrt1_s (float)`
`double __builtin_mips_rsqrt1_d (double)`
`v2sf __builtin_mips_rsqrt1_ps (v2sf)`
  Reduced-precision reciprocal square root (sequence step 1) (`rsqrt1.`fmt).
`float __builtin_mips_rsqrt2_s (float, float)`
`double __builtin_mips_rsqrt2_d (double, double)`
`v2sf __builtin_mips_rsqrt2_ps (v2sf, v2sf)`
  Reduced-precision reciprocal square root (sequence step 2) (`rsqrt2.`fmt).

The following multi-instruction functions are also available. In each case, cond can be any of the 16 floating-point conditions: `f`, `un`, `eq`, `ueq`, `olt`, `ult`, `ole`, `ule`, `sf`, `ngle`, `seq`, `ngl`, `lt`, `nge`, `le` or `ngt`.

`int __builtin_mips_cabs_`cond`_s (float` a`, float` b`)`
`int __builtin_mips_cabs_`cond`_d (double` a`, double` b`)`
  Absolute comparison of two scalar values (`cabs.`cond`.`fmt, `bc1t`/`bc1f`).

  These functions compare a and b using `cabs.`cond`.s` or `cabs.`cond`.d` and return the result as a boolean value. For example:

                float a, b;
                if (__builtin_mips_cabs_eq_s (a, b))
                  true ();
                else
                  false ();

`int __builtin_mips_upper_cabs_`cond`_ps (v2sf` a`, v2sf` b`)`
`int __builtin_mips_lower_cabs_`cond`_ps (v2sf` a`, v2sf` b`)`
  Absolute comparison of two paired-single values (`cabs.`cond`.ps`, `bc1t`/`bc1f`).

  These functions compare a and b using `cabs.`cond`.ps` and return either the upper or lower half of the result. For example:

                v2sf a, b;
                if (__builtin_mips_upper_cabs_eq_ps (a, b))
                  upper_halves_are_equal ();
                else
                  upper_halves_are_unequal ();

                if (__builtin_mips_lower_cabs_eq_ps (a, b))
                  lower_halves_are_equal ();
                else
                  lower_halves_are_unequal ();

`v2sf __builtin_mips_movt_cabs_`cond`_ps (v2sf` a`, v2sf` b`, v2sf` c`, v2sf` d`)`
`v2sf __builtin_mips_movf_cabs_`cond`_ps (v2sf` a`, v2sf` b`, v2sf` c`, v2sf` d`)`
  Conditional move based on absolute comparison (`cabs.`cond`.ps`, `movt.ps`/`movf.ps`).

  The `movt` functions return the value x computed by:

                cabs.cond.ps cc,a,b
                mov.ps x,c
                movt.ps x,d,cc

  The `movf` functions are similar but use `movf.ps` instead of `movt.ps`.

`int __builtin_mips_any_c_`cond`_ps (v2sf` a`, v2sf` b`)`
`int __builtin_mips_all_c_`cond`_ps (v2sf` a`, v2sf` b`)`
`int __builtin_mips_any_cabs_`cond`_ps (v2sf` a`, v2sf` b`)`
`int __builtin_mips_all_cabs_`cond`_ps (v2sf` a`, v2sf` b`)`
  Comparison of two paired-single values (`c.`cond`.ps`/`cabs.`cond`.ps`, `bc1any2t`/`bc1any2f`).

  These functions compare a and b using `c.`cond`.ps` or `cabs.`cond`.ps`. The `any` forms return true if either result is true and the `all` forms return true if both results are true. For example:

                v2sf a, b;
                if (__builtin_mips_any_c_eq_ps (a, b))
                  one_is_true ();
                else
                  both_are_false ();

                if (__builtin_mips_all_c_eq_ps (a, b))
                  both_are_true ();
                else
                  one_is_false ();

`int __builtin_mips_any_c_`cond`_4s (v2sf` a`, v2sf` b`, v2sf` c`, v2sf` d`)`
`int __builtin_mips_all_c_`cond`_4s (v2sf` a`, v2sf` b`, v2sf` c`, v2sf` d`)`
`int __builtin_mips_any_cabs_`cond`_4s (v2sf` a`, v2sf` b`, v2sf` c`, v2sf` d`)`
`int __builtin_mips_all_cabs_`cond`_4s (v2sf` a`, v2sf` b`, v2sf` c`, v2sf` d`)`
  Comparison of four paired-single values (`c.`cond`.ps`/`cabs.`cond`.ps`, `bc1any4t`/`bc1any4f`).

  These functions use `c.`cond`.ps` or `cabs.`cond`.ps` to compare a with b and to compare c with d. The `any` forms return true if any of the four results are true and the `all` forms return true if all four results are true. For example:

                v2sf a, b, c, d;
                if (__builtin_mips_any_c_eq_4s (a, b, c, d))
                  some_are_true ();
                else
                  all_are_false ();

                if (__builtin_mips_all_c_eq_4s (a, b, c, d))
                  all_are_true ();
                else
                  some_are_false ();